import { GenerateResultVO, ImageCategoryVO, TaskType } from '@/types/ai';
import { defineStore } from 'pinia';
import { AiAPI } from '@/api/ai';
import { AIType } from '@/types/ai';
import router from '@/router/route';
import { useUserStore } from './user';

// 添加定时器类型定义
interface AiState {
  results: GenerateResultVO[];
  isLoading: boolean;
  categoriesText: ImageCategoryVO[];
  categoriesImage: ImageCategoryVO[];
  // 添加定时器ID字段
  refreshTimer: NodeJS.Timeout | null;
}

export const useAiStore = defineStore('aiStore', {
  state: (): AiState => ({
    results: [],
    isLoading: false,
    categoriesText: [],
    categoriesImage: [],
    // 初始化定时器为null
    refreshTimer: null,
  }),

  getters: {},

  actions: {
    /**
     * 获取生成结果列表
     * @param genType 生成类型，默认为文本生成
     */
    async getGenerateResults() {
      const userStore = useUserStore();
      if (!userStore.isLoggedIn) {
        return;
      }

      this.isLoading = true;
      const aid = (router && (router.currentRoute.value.query.aid as string)) || '';

      try {
        const params = {
          gen_type: AIType.ALL,
          aid: aid as string,
        };
        const response = await AiAPI.getGenerateResult(params);
        const list = response?.data || [];

        // 处理返回的数据格式
        list.forEach((item: any) => {
          if (item.status === TaskType.PROCESSING || item.status === TaskType.FAIL) {
            // 占位
            const mocks =
              !item.gen_template ||
              [(AIType.EDIT, AIType.HD)].includes((item.gen_template || {}).gen_type)
                ? [1]
                : [1, 2, 3, 4];

            item.imgs = mocks.map((cItem: any, index: number) => {
              return {
                url: '',
                id: 0,
                isCheck: false,
                prompt_text: '',
                task_id: 0,
              };
            });
          } else {
            item.imgs = item?.result_imgs?.map((cItem: any, index: number) => {
              return {
                url: cItem.img_url,
                id: cItem.img_id,
                isCheck: false,
                prompt_text: item.prompt_text,
                task_id: item.task_id,
              };
            });
          }
        });

        this.results = list;

        // 检查是否有进行中的任务
        const hasProcessingTasks = list.some(
          (item: GenerateResultVO) => item.status === TaskType.PROCESSING
        );

        if (hasProcessingTasks) {
          // 如果有进行中的任务，启动自动刷新
          setTimeout(() => {
            this.getGenerateResults();
          }, 5000);
        }
        return list;
      } catch (error) {
        console.error('获取生成结果失败:', error);
        return [];
      } finally {
        this.isLoading = false;
      }
    },

    /**
     * 启动自动刷新生成结果
     * @param interval 刷新间隔（毫秒），默认3000ms（3秒）
     */
    startAutoRefresh(interval: number = 3000) {
      // 先停止已有的定时器
      this.stopAutoRefresh();

      // 设置新的定时器
      this.refreshTimer = setInterval(async () => {
        try {
          await this.getGenerateResults();
        } catch (error) {
          console.error('自动刷新生成结果失败:', error);
        }
      }, interval);
    },

    /**
     * 停止自动刷新生成结果
     */
    stopAutoRefresh() {
      if (this.refreshTimer) {
        clearInterval(this.refreshTimer);
        this.refreshTimer = null;
      }
    },

    /**
     * 清空结果列表
     */
    clearResults() {
      this.results = [];
    },

    /**
     * 设置文本分类列表
     * @param categories 分类列表
     */
    setCategoriesText(categories: ImageCategoryVO[]) {
      this.categoriesText = categories;
    },

    /**
     * 设置图片分类列表
     * @param categories 分类列表
     */
    setCategoriesImage(categories: ImageCategoryVO[]) {
      this.categoriesImage = categories;
    },
  },
});
